home *** CD-ROM | disk | FTP | other *** search
/ CU Amiga Super CD-ROM 14 / CU Amiga Magazine's Super CD-ROM 14 (1997)(EMAP Images)(GB)(Track 1 of 3)[!][issue 1997-09].iso / CUCD / Programming / Mesa-2.2 / src / enable.c < prev    next >
Encoding:
C/C++ Source or Header  |  1997-03-13  |  18.4 KB  |  653 lines
  1. /* $Id: enable.c,v 1.13 1997/02/27 19:59:08 brianp Exp $ */
  2.  
  3. /*
  4.  * Mesa 3-D graphics library
  5.  * Version:  2.2
  6.  * Copyright (C) 1995-1997  Brian Paul
  7.  *
  8.  * This library is free software; you can redistribute it and/or
  9.  * modify it under the terms of the GNU Library General Public
  10.  * License as published by the Free Software Foundation; either
  11.  * version 2 of the License, or (at your option) any later version.
  12.  *
  13.  * This library is distributed in the hope that it will be useful,
  14.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  16.  * Library General Public License for more details.
  17.  *
  18.  * You should have received a copy of the GNU Library General Public
  19.  * License along with this library; if not, write to the Free
  20.  * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  21.  */
  22.  
  23.  
  24. /*
  25.  * $Log: enable.c,v $
  26.  * Revision 1.13  1997/02/27 19:59:08  brianp
  27.  * issue a warning if enable depth or stencil test without such a buffer
  28.  *
  29.  * Revision 1.12  1997/02/09 19:53:43  brianp
  30.  * now use TEXTURE_xD enable constants
  31.  *
  32.  * Revision 1.11  1997/02/09 18:49:37  brianp
  33.  * added GL_EXT_texture3D support
  34.  *
  35.  * Revision 1.10  1997/01/28 22:13:42  brianp
  36.  * now there's separate state for CI and RGBA logic op enabled
  37.  *
  38.  * Revision 1.9  1996/12/18 20:00:57  brianp
  39.  * gl_set_material() now takes a bitmask instead of face and pname
  40.  *
  41.  * Revision 1.8  1996/12/11 20:16:49  brianp
  42.  * more work on the GL_COLOR_MATERIAL bug
  43.  *
  44.  * Revision 1.7  1996/12/09 22:51:51  brianp
  45.  * update API Color4f and Color4ub pointers for GL_COLOR_MATERIAL
  46.  *
  47.  * Revision 1.6  1996/12/07 10:21:07  brianp
  48.  * call gl_set_material() instead of gl_Materialfv()
  49.  *
  50.  * Revision 1.5  1996/11/09 03:11:18  brianp
  51.  * added missing GL_EXT_vertex_array caps to gl_enable()
  52.  *
  53.  * Revision 1.4  1996/10/11 03:44:09  brianp
  54.  * added comments for GL_POLYGON_OFFSET_EXT symbol
  55.  *
  56.  * Revision 1.3  1996/09/27 01:26:40  brianp
  57.  * removed unused variables
  58.  *
  59.  * Revision 1.2  1996/09/15 14:17:30  brianp
  60.  * now use GLframebuffer and GLvisual
  61.  *
  62.  * Revision 1.1  1996/09/13 01:38:16  brianp
  63.  * Initial revision
  64.  *
  65.  */
  66.  
  67.  
  68. #include <string.h>
  69. #include "context.h"
  70. #include "depth.h"
  71. #include "draw.h"
  72. #include "enable.h"
  73. #include "light.h"
  74. #include "dlist.h"
  75. #include "macros.h"
  76. #include "stencil.h"
  77. #include "types.h"
  78. #include "vertex.h"
  79.  
  80.  
  81.  
  82. /*
  83.  * Perform glEnable and glDisable calls.
  84.  */
  85. static void gl_enable( GLcontext* ctx, GLenum cap, GLboolean state )
  86. {
  87.    GLuint p;
  88.  
  89.    if (INSIDE_BEGIN_END(ctx)) {
  90.       if (state) {
  91.      gl_error( ctx, GL_INVALID_OPERATION, "glEnable" );
  92.       }
  93.       else {
  94.      gl_error( ctx, GL_INVALID_OPERATION, "glDisable" );
  95.       }
  96.       return;
  97.    }
  98.  
  99.    switch (cap) {
  100.       case GL_ALPHA_TEST:
  101.          if (ctx->Color.AlphaEnabled!=state) {
  102.             ctx->Color.AlphaEnabled = state;
  103.             ctx->NewState |= NEW_RASTER_OPS;
  104.          }
  105.      break;
  106.       case GL_AUTO_NORMAL:
  107.      ctx->Eval.AutoNormal = state;
  108.      break;
  109.       case GL_BLEND:
  110.          if (ctx->Color.BlendEnabled!=state) {
  111.             ctx->Color.BlendEnabled = state;
  112.             /* The following needed to accomodate 1.0 RGB logic op blending */
  113.             if (ctx->Color.BlendEquation==GL_LOGIC_OP && state) {
  114.                ctx->Color.ColorLogicOpEnabled = GL_TRUE;
  115.             }
  116.             else {
  117.                ctx->Color.ColorLogicOpEnabled = GL_FALSE;
  118.             }
  119.             ctx->NewState |= NEW_RASTER_OPS;
  120.          }
  121.      break;
  122.       case GL_CLIP_PLANE0:
  123.       case GL_CLIP_PLANE1:
  124.       case GL_CLIP_PLANE2:
  125.       case GL_CLIP_PLANE3:
  126.       case GL_CLIP_PLANE4:
  127.       case GL_CLIP_PLANE5:
  128.      ctx->Transform.ClipEnabled[cap-GL_CLIP_PLANE0] = state;
  129.      /* Check if any clip planes enabled */
  130.          ctx->Transform.AnyClip = GL_FALSE;
  131.          for (p=0;p<MAX_CLIP_PLANES;p++) {
  132.             if (ctx->Transform.ClipEnabled[p]) {
  133.                ctx->Transform.AnyClip = GL_TRUE;
  134.                break;
  135.             }
  136.          }
  137.      break;
  138.       case GL_COLOR_MATERIAL:
  139.          if (ctx->Light.ColorMaterialEnabled!=state) {
  140.             ctx->Light.ColorMaterialEnabled = state;
  141.             if (state) {
  142.                GLfloat color[4];
  143.                color[0] = ctx->Current.IntColor[0] * ctx->Visual->InvRedScale;
  144.                color[1] = ctx->Current.IntColor[1] * ctx->Visual->InvGreenScale;
  145.                color[2] = ctx->Current.IntColor[2] * ctx->Visual->InvBlueScale;
  146.                color[3] = ctx->Current.IntColor[3] * ctx->Visual->InvAlphaScale;
  147.                /* update material with current color */
  148.                gl_set_material( ctx, ctx->Light.ColorMaterialBitmask, color );
  149.  
  150.                /* update the Color4f and Color4ub API pointers */
  151.                ctx->Exec.Color4f = gl_ColorMat4f;
  152.                ctx->Exec.Color4ub = gl_ColorMat4ub;
  153.             }
  154.             else {
  155.                /* update the Color4f and Color4ub API pointers */
  156.                ctx->Exec.Color4f = gl_Color4f;
  157.                if (ctx->Visual->EightBitColor) {
  158.                   ctx->Exec.Color4ub = gl_Color4ub8bit;
  159.                }
  160.                else {
  161.                   ctx->Exec.Color4ub = gl_Color4ub;
  162.                }
  163.             }
  164.             if (!ctx->CompileFlag) {
  165.                ctx->API.Color4f = ctx->Exec.Color4f;
  166.                ctx->API.Color4ub = ctx->Exec.Color4ub;
  167.             }
  168.             ctx->NewState |= NEW_LIGHTING;
  169.          }
  170.      break;
  171.       case GL_CULL_FACE:
  172.          if (ctx->Polygon.CullFlag!=state) {
  173.             ctx->Polygon.CullFlag = state;
  174.             ctx->NewState |= NEW_RASTER_OPS;
  175.          }
  176.      break;
  177.       case GL_DEPTH_TEST:
  178.          if (state && ctx->Visual->DepthBits==0) {
  179.             gl_warning(ctx,"glEnable(GL_DEPTH_TEST) but no depth buffer");
  180.             return;
  181.          }
  182.      if (ctx->Depth.Test!=state) {
  183.             ctx->Depth.Test = state;
  184.             ctx->NewState |= NEW_RASTER_OPS;
  185.          }
  186.          break;
  187.       case GL_DITHER:
  188.      ctx->Color.DitherFlag = state;
  189.          if (ctx->Driver.Dither) {
  190.             (*ctx->Driver.Dither)( ctx, state );
  191.          }
  192.          ctx->NewState |= NEW_RASTER_OPS;
  193.      break;
  194.       case GL_FOG:
  195.      if (ctx->Fog.Enabled!=state) {
  196.             ctx->Fog.Enabled = state;
  197.             ctx->NewState |= NEW_RASTER_OPS;
  198.          }
  199.      break;
  200.       case GL_LIGHT0:
  201.       case GL_LIGHT1:
  202.       case GL_LIGHT2:
  203.       case GL_LIGHT3:
  204.       case GL_LIGHT4:
  205.       case GL_LIGHT5:
  206.       case GL_LIGHT6:
  207.       case GL_LIGHT7:
  208.          ctx->Light.Light[cap-GL_LIGHT0].Enabled = state;
  209.          ctx->NewState |= NEW_LIGHTING;
  210.          break;
  211.       case GL_LIGHTING:
  212.          if (ctx->Light.Enabled!=state) {
  213.             ctx->Light.Enabled = state;
  214.             ctx->NewState |= NEW_LIGHTING;
  215.          }
  216.          break;
  217.       case GL_LINE_SMOOTH:
  218.      if (ctx->Line.SmoothFlag!=state) {
  219.             ctx->Line.SmoothFlag = state;
  220.             ctx->NewState |= NEW_RASTER_OPS;
  221.          }
  222.      break;
  223.       case GL_LINE_STIPPLE:
  224.      if (ctx->Line.StippleFlag!=state) {
  225.             ctx->Line.StippleFlag = state;
  226.             ctx->NewState |= NEW_RASTER_OPS;
  227.          }
  228.      break;
  229.       case GL_INDEX_LOGIC_OP:
  230.          if (ctx->Color.IndexLogicOpEnabled!=state) {
  231.             ctx->NewState |= NEW_RASTER_OPS;
  232.          }
  233.      ctx->Color.IndexLogicOpEnabled = state;
  234.      break;
  235.       case GL_COLOR_LOGIC_OP:
  236.          if (ctx->Color.ColorLogicOpEnabled!=state) {
  237.             ctx->NewState |= NEW_RASTER_OPS;
  238.          }
  239.      ctx->Color.ColorLogicOpEnabled = state;
  240.      break;
  241.       case GL_MAP1_COLOR_4:
  242.      ctx->Eval.Map1Color4 = state;
  243.      break;
  244.       case GL_MAP1_INDEX:
  245.      ctx->Eval.Map1Index = state;
  246.      break;
  247.       case GL_MAP1_NORMAL:
  248.      ctx->Eval.Map1Normal = state;
  249.      break;
  250.       case GL_MAP1_TEXTURE_COORD_1:
  251.      ctx->Eval.Map1TextureCoord1 = state;
  252.      break;
  253.       case GL_MAP1_TEXTURE_COORD_2:
  254.      ctx->Eval.Map1TextureCoord2 = state;
  255.      break;
  256.       case GL_MAP1_TEXTURE_COORD_3:
  257.      ctx->Eval.Map1TextureCoord3 = state;
  258.      break;
  259.       case GL_MAP1_TEXTURE_COORD_4:
  260.      ctx->Eval.Map1TextureCoord4 = state;
  261.      break;
  262.       case GL_MAP1_VERTEX_3:
  263.      ctx->Eval.Map1Vertex3 = state;
  264.      break;
  265.       case GL_MAP1_VERTEX_4:
  266.      ctx->Eval.Map1Vertex4 = state;
  267.      break;
  268.       case GL_MAP2_COLOR_4:
  269.      ctx->Eval.Map2Color4 = state;
  270.      break;
  271.       case GL_MAP2_INDEX:
  272.      ctx->Eval.Map2Index = state;
  273.      break;
  274.       case GL_MAP2_NORMAL:
  275.      ctx->Eval.Map2Normal = state;
  276.      break;
  277.       case GL_MAP2_TEXTURE_COORD_1: 
  278.      ctx->Eval.Map2TextureCoord1 = state;
  279.      break;
  280.       case GL_MAP2_TEXTURE_COORD_2:
  281.      ctx->Eval.Map2TextureCoord2 = state;
  282.      break;
  283.       case GL_MAP2_TEXTURE_COORD_3:
  284.      ctx->Eval.Map2TextureCoord3 = state;
  285.      break;
  286.       case GL_MAP2_TEXTURE_COORD_4:
  287.      ctx->Eval.Map2TextureCoord4 = state;
  288.      break;
  289.       case GL_MAP2_VERTEX_3:
  290.      ctx->Eval.Map2Vertex3 = state;
  291.      break;
  292.       case GL_MAP2_VERTEX_4:
  293.      ctx->Eval.Map2Vertex4 = state;
  294.      break;
  295.       case GL_NORMALIZE:
  296.      ctx->Transform.Normalize = state;
  297.      break;
  298.       case GL_POINT_SMOOTH:
  299.      if (ctx->Point.SmoothFlag!=state) {
  300.             ctx->Point.SmoothFlag = state;
  301.             ctx->NewState |= NEW_RASTER_OPS;
  302.          }
  303.      break;
  304.       case GL_POLYGON_SMOOTH:
  305.      if (ctx->Polygon.SmoothFlag!=state) {
  306.             ctx->Polygon.SmoothFlag = state;
  307.             ctx->NewState |= NEW_RASTER_OPS;
  308.          }
  309.      break;
  310.       case GL_POLYGON_STIPPLE:
  311.      if (ctx->Polygon.StippleFlag!=state) {
  312.             ctx->Polygon.StippleFlag = state;
  313.             ctx->NewState |= NEW_RASTER_OPS;
  314.          }
  315.      break;
  316.       case GL_POLYGON_OFFSET_POINT:
  317.          if (ctx->Polygon.OffsetPoint!=state) {
  318.             ctx->Polygon.OffsetPoint = state;
  319.             ctx->NewState |= NEW_RASTER_OPS;
  320.          }
  321.          break;
  322.       case GL_POLYGON_OFFSET_LINE:
  323.          if (ctx->Polygon.OffsetLine!=state) {
  324.             ctx->Polygon.OffsetLine = state;
  325.             ctx->NewState |= NEW_RASTER_OPS;
  326.          }
  327.          break;
  328.       case GL_POLYGON_OFFSET_FILL:
  329.       /*case GL_POLYGON_OFFSET_EXT:*/
  330.          if (ctx->Polygon.OffsetFill!=state) {
  331.             ctx->Polygon.OffsetFill = state;
  332.             ctx->NewState |= NEW_RASTER_OPS;
  333.          }
  334.          break;
  335.       case GL_SCISSOR_TEST:
  336.          if (ctx->Scissor.Enabled!=state) {
  337.             ctx->Scissor.Enabled = state;
  338.             ctx->NewState |= NEW_RASTER_OPS;
  339.          }
  340.      break;
  341.       case GL_STENCIL_TEST:
  342.      if (state && ctx->Visual->StencilBits==0) {
  343.             gl_warning(ctx, "glEnable(GL_STENCIL_TEST) but no stencil buffer");
  344.             return;
  345.      }
  346.      if (ctx->Stencil.Enabled!=state) {
  347.             ctx->Stencil.Enabled = state;
  348.             ctx->NewState |= NEW_RASTER_OPS;
  349.          }
  350.      break;
  351.       case GL_TEXTURE_1D:
  352.          if (ctx->Visual->RGBAflag) {
  353.             /* texturing only works in RGB mode */
  354.             if (state) {
  355.                ctx->Texture.Enabled |= TEXTURE_1D;
  356.             }
  357.             else {
  358.                ctx->Texture.Enabled &= (~TEXTURE_1D);
  359.             }
  360.             ctx->NewState |= (NEW_RASTER_OPS | NEW_TEXTURING);
  361.          }
  362.      break;
  363.       case GL_TEXTURE_2D:
  364.          if (ctx->Visual->RGBAflag) {
  365.             /* texturing only works in RGB mode */
  366.             if (state) {
  367.                ctx->Texture.Enabled |= TEXTURE_2D;
  368.             }
  369.             else {
  370.                ctx->Texture.Enabled &= (~TEXTURE_2D);
  371.             }
  372.             ctx->NewState |= (NEW_RASTER_OPS | NEW_TEXTURING);
  373.          }
  374.      break;
  375.       case GL_TEXTURE_3D_EXT:
  376.          if (ctx->Visual->RGBAflag) {
  377.             /* texturing only works in RGB mode */
  378.             if (state) {
  379.                ctx->Texture.Enabled |= TEXTURE_3D;
  380.             }
  381.             else {
  382.                ctx->Texture.Enabled &= (~TEXTURE_3D);
  383.             }
  384.             ctx->NewState |= (NEW_RASTER_OPS | NEW_TEXTURING);
  385.          }
  386.          break;
  387.       case GL_TEXTURE_GEN_Q:
  388.          if (state) {
  389.             ctx->Texture.TexGenEnabled |= Q_BIT;
  390.          }
  391.          else {
  392.             ctx->Texture.TexGenEnabled &= ~Q_BIT;
  393.          }
  394.          ctx->NewState |= NEW_TEXTURING;
  395.      break;
  396.       case GL_TEXTURE_GEN_R:
  397.          if (state) {
  398.             ctx->Texture.TexGenEnabled |= R_BIT;
  399.          }
  400.          else {
  401.             ctx->Texture.TexGenEnabled &= ~R_BIT;
  402.          }
  403.          ctx->NewState |= NEW_TEXTURING;
  404.      break;
  405.       case GL_TEXTURE_GEN_S:
  406.      if (state) {
  407.             ctx->Texture.TexGenEnabled |= S_BIT;
  408.          }
  409.          else {
  410.             ctx->Texture.TexGenEnabled &= ~S_BIT;
  411.          }
  412.          ctx->NewState |= NEW_TEXTURING;
  413.      break;
  414.       case GL_TEXTURE_GEN_T:
  415.          if (state) {
  416.             ctx->Texture.TexGenEnabled |= T_BIT;
  417.          }
  418.          else {
  419.             ctx->Texture.TexGenEnabled &= ~T_BIT;
  420.          }
  421.          ctx->NewState |= NEW_TEXTURING;
  422.      break;
  423.  
  424.       /*
  425.        * CLIENT STATE!!!
  426.        */
  427.       case GL_VERTEX_ARRAY:
  428.          ctx->Array.VertexEnabled = state;
  429.          break;
  430.       case GL_NORMAL_ARRAY:
  431.          ctx->Array.NormalEnabled = state;
  432.          break;
  433.       case GL_COLOR_ARRAY:
  434.          ctx->Array.ColorEnabled = state;
  435.          break;
  436.       case GL_INDEX_ARRAY:
  437.          ctx->Array.IndexEnabled = state;
  438.          break;
  439.       case GL_TEXTURE_COORD_ARRAY:
  440.          ctx->Array.TexCoordEnabled = state;
  441.          break;
  442.       case GL_EDGE_FLAG_ARRAY:
  443.          ctx->Array.EdgeFlagEnabled = state;
  444.          break;
  445.  
  446.       default:
  447.      if (state) {
  448.         gl_error( ctx, GL_INVALID_ENUM, "glEnable" );
  449.      }
  450.      else {
  451.         gl_error( ctx, GL_INVALID_ENUM, "glDisable" );
  452.      }
  453.          break;
  454.    }
  455. }
  456.  
  457.  
  458.  
  459.  
  460. void gl_Enable( GLcontext* ctx, GLenum cap )
  461. {
  462.    gl_enable( ctx, cap, GL_TRUE );
  463. }
  464.  
  465.  
  466.  
  467. void gl_Disable( GLcontext* ctx, GLenum cap )
  468. {
  469.    gl_enable( ctx, cap, GL_FALSE );
  470. }
  471.  
  472.  
  473.  
  474. GLboolean gl_IsEnabled( GLcontext* ctx, GLenum cap )
  475. {
  476.    switch (cap) {
  477.       case GL_ALPHA_TEST:
  478.          return ctx->Color.AlphaEnabled;
  479.       case GL_AUTO_NORMAL:
  480.      return ctx->Eval.AutoNormal;
  481.       case GL_BLEND:
  482.          return ctx->Color.BlendEnabled;
  483.       case GL_CLIP_PLANE0:
  484.       case GL_CLIP_PLANE1:
  485.       case GL_CLIP_PLANE2:
  486.       case GL_CLIP_PLANE3:
  487.       case GL_CLIP_PLANE4:
  488.       case GL_CLIP_PLANE5:
  489.      return ctx->Transform.ClipEnabled[cap-GL_CLIP_PLANE0];
  490.       case GL_COLOR_MATERIAL:
  491.      return ctx->Light.ColorMaterialEnabled;
  492.       case GL_CULL_FACE:
  493.          return ctx->Polygon.CullFlag;
  494.       case GL_DEPTH_TEST:
  495.          return ctx->Depth.Test;
  496.       case GL_DITHER:
  497.      return ctx->Color.DitherFlag;
  498.       case GL_FOG:
  499.      return ctx->Fog.Enabled;
  500.       case GL_LIGHTING:
  501.          return ctx->Light.Enabled;
  502.       case GL_LIGHT0:
  503.       case GL_LIGHT1:
  504.       case GL_LIGHT2:
  505.       case GL_LIGHT3:
  506.       case GL_LIGHT4:
  507.       case GL_LIGHT5:
  508.       case GL_LIGHT6:
  509.       case GL_LIGHT7:
  510.          return ctx->Light.Light[cap-GL_LIGHT0].Enabled;
  511.       case GL_LINE_SMOOTH:
  512.      return ctx->Line.SmoothFlag;
  513.       case GL_LINE_STIPPLE:
  514.      return ctx->Line.StippleFlag;
  515.       case GL_INDEX_LOGIC_OP:
  516.      return ctx->Color.IndexLogicOpEnabled;
  517.       case GL_COLOR_LOGIC_OP:
  518.      return ctx->Color.ColorLogicOpEnabled;
  519.       case GL_MAP1_COLOR_4:
  520.      return ctx->Eval.Map1Color4;
  521.       case GL_MAP1_INDEX:
  522.      return ctx->Eval.Map1Index;
  523.       case GL_MAP1_NORMAL:
  524.      return ctx->Eval.Map1Normal;
  525.       case GL_MAP1_TEXTURE_COORD_1:
  526.      return ctx->Eval.Map1TextureCoord1;
  527.       case GL_MAP1_TEXTURE_COORD_2:
  528.      return ctx->Eval.Map1TextureCoord2;
  529.       case GL_MAP1_TEXTURE_COORD_3:
  530.      return ctx->Eval.Map1TextureCoord3;
  531.       case GL_MAP1_TEXTURE_COORD_4:
  532.      return ctx->Eval.Map1TextureCoord4;
  533.       case GL_MAP1_VERTEX_3:
  534.      return ctx->Eval.Map1Vertex3;
  535.       case GL_MAP1_VERTEX_4:
  536.      return ctx->Eval.Map1Vertex4;
  537.       case GL_MAP2_COLOR_4:
  538.      return ctx->Eval.Map2Color4;
  539.       case GL_MAP2_INDEX:
  540.      return ctx->Eval.Map2Index;
  541.       case GL_MAP2_NORMAL:
  542.      return ctx->Eval.Map2Normal;
  543.       case GL_MAP2_TEXTURE_COORD_1: 
  544.      return ctx->Eval.Map2TextureCoord1;
  545.       case GL_MAP2_TEXTURE_COORD_2:
  546.      return ctx->Eval.Map2TextureCoord2;
  547.       case GL_MAP2_TEXTURE_COORD_3:
  548.      return ctx->Eval.Map2TextureCoord3;
  549.       case GL_MAP2_TEXTURE_COORD_4:
  550.      return ctx->Eval.Map2TextureCoord4;
  551.       case GL_MAP2_VERTEX_3:
  552.      return ctx->Eval.Map2Vertex3;
  553.       case GL_MAP2_VERTEX_4:
  554.      return ctx->Eval.Map2Vertex4;
  555.       case GL_NORMALIZE:
  556.      return ctx->Transform.Normalize;
  557.       case GL_POINT_SMOOTH:
  558.      return ctx->Point.SmoothFlag;
  559.       case GL_POLYGON_SMOOTH:
  560.      return ctx->Polygon.SmoothFlag;
  561.       case GL_POLYGON_STIPPLE:
  562.      return ctx->Polygon.StippleFlag;
  563.       case GL_POLYGON_OFFSET_POINT:
  564.      return ctx->Polygon.OffsetPoint;
  565.       case GL_POLYGON_OFFSET_LINE:
  566.      return ctx->Polygon.OffsetLine;
  567.       case GL_POLYGON_OFFSET_FILL:
  568.       /*case GL_POLYGON_OFFSET_EXT:*/
  569.      return ctx->Polygon.OffsetFill;
  570.       case GL_SCISSOR_TEST:
  571.      return ctx->Scissor.Enabled;
  572.       case GL_STENCIL_TEST:
  573.      return ctx->Stencil.Enabled;
  574.       case GL_TEXTURE_1D:
  575.      return (ctx->Texture.Enabled & TEXTURE_1D) ? GL_TRUE : GL_FALSE;
  576.       case GL_TEXTURE_2D:
  577.      return (ctx->Texture.Enabled & TEXTURE_2D) ? GL_TRUE : GL_FALSE;
  578.       case GL_TEXTURE_3D_EXT:
  579.          return (ctx->Texture.Enabled & TEXTURE_3D) ? GL_TRUE : GL_FALSE;
  580.       case GL_TEXTURE_GEN_Q:
  581.      return (ctx->Texture.TexGenEnabled & Q_BIT) ? GL_TRUE : GL_FALSE;
  582.       case GL_TEXTURE_GEN_R:
  583.      return (ctx->Texture.TexGenEnabled & R_BIT) ? GL_TRUE : GL_FALSE;
  584.       case GL_TEXTURE_GEN_S:
  585.      return (ctx->Texture.TexGenEnabled & S_BIT) ? GL_TRUE : GL_FALSE;
  586.       case GL_TEXTURE_GEN_T:
  587.      return (ctx->Texture.TexGenEnabled & T_BIT) ? GL_TRUE : GL_FALSE;
  588.  
  589.       /*
  590.        * CLIENT STATE!!!
  591.        */
  592.       case GL_VERTEX_ARRAY:
  593.          return ctx->Array.VertexEnabled;
  594.       case GL_NORMAL_ARRAY:
  595.          return ctx->Array.NormalEnabled;
  596.       case GL_COLOR_ARRAY:
  597.          return ctx->Array.ColorEnabled;
  598.       case GL_INDEX_ARRAY:
  599.          return ctx->Array.IndexEnabled;
  600.       case GL_TEXTURE_COORD_ARRAY:
  601.          return ctx->Array.TexCoordEnabled;
  602.       case GL_EDGE_FLAG_ARRAY:
  603.          return ctx->Array.EdgeFlagEnabled;
  604.       default:
  605.      gl_error( ctx, GL_INVALID_ENUM, "glIsEnabled" );
  606.      return GL_FALSE;
  607.    }
  608. }
  609.  
  610.  
  611.  
  612.  
  613. void gl_client_state( GLcontext *ctx, GLenum cap, GLboolean state )
  614. {
  615.    switch (cap) {
  616.       case GL_VERTEX_ARRAY:
  617.          ctx->Array.VertexEnabled = state;
  618.          break;
  619.       case GL_NORMAL_ARRAY:
  620.          ctx->Array.NormalEnabled = state;
  621.          break;
  622.       case GL_COLOR_ARRAY:
  623.          ctx->Array.ColorEnabled = state;
  624.          break;
  625.       case GL_INDEX_ARRAY:
  626.          ctx->Array.IndexEnabled = state;
  627.          break;
  628.       case GL_TEXTURE_COORD_ARRAY:
  629.          ctx->Array.TexCoordEnabled = state;
  630.          break;
  631.       case GL_EDGE_FLAG_ARRAY:
  632.          ctx->Array.EdgeFlagEnabled = state;
  633.          break;
  634.       default:
  635.          gl_error( ctx, GL_INVALID_ENUM, "glEnable/DisableClientState" );
  636.    }
  637. }
  638.  
  639.  
  640.  
  641. void gl_EnableClientState( GLcontext *ctx, GLenum cap )
  642. {
  643.    gl_client_state( ctx, cap, GL_TRUE );
  644. }
  645.  
  646.  
  647.  
  648. void gl_DisableClientState( GLcontext *ctx, GLenum cap )
  649. {
  650.    gl_client_state( ctx, cap, GL_FALSE );
  651. }
  652.  
  653.